Dynamically diagnosing type errors in unsafe code

Existing approaches for detecting type errors in unsafe languages are limited. Static analysis methods are imprecise, and often require source-level changes, while most dynamic methods check only memory properties (bounds, liveness, etc.), owing to a lack of run-time type information. This paper describes libcrunch, a system for binary-compatible run-time type checking of unmodified unsafe code, currently focusing on C. Practical experience shows that our prototype implementation is easily applicable to many real codebases without source-level modification, correctly flags programmer errors with a very low rate of false positives, offers a very low run-time overhead, and covers classes of error caught by no previously existing tool

Composing heterogeneous software with style

ABSTRACT Tools for composing software impose homogeneity requirements on what is composed-that modules must share a language, target the same libraries, or share other conventions. This inhibits cross-language and cross-infrastructure composition. We observe that a unifying representation of software turns heterogeneity of components into a matter of styles: recurring interface patterns that cross-cut large numbers of codebases. We sketch a rule-based language for capturing styles independently of composition context, and describe how it applies in two example scenarios

A survey of practical software adaptation techniques

Abstract: Software adaptation techniques appear in many disparate areas of research literature, and under many guises. This paper enables a clear and uniform understanding of the related research, in three ways. Firstly, it surveys a broad range of relevant research, describing and contrasting the approaches of each using a uniform terminological and conceptual vocabulary. Secondly, it identifies and discusses three commonly advocated principles within this work: component models, first-class connection and loose coupling. Thirdly, it identifies and compares the various modularisation strategies employed by the surveyed work

Fitting Transporter Activities to Cellular Drug Concentrations and Fluxes: Why the Bumblebee Can Fly

A recent paper in this journal argued that reported expression levels, kcat and Km for drug transporters could be used to estimate the likelihood that drug fluxes through Caco-2 cells could be accounted for solely by protein transporters. It was in fact concluded that if five such transporters contributed ‘randomly’ they could account for the flux of the most permeable drug tested (verapamil) 35% of the time. However, the values of permeability cited for verapamil were unusually high; this and other drugs have much lower permeabilities. Even for the claimed permeabilities, we found that a single ‘random’ transporter could account for the flux 42% of the time, and that two transporters can achieve 10·10−6cm·s−1 90% of the time. Parameter optimisation methods show that even a single transporter can account for Caco-2 drug uptake of the most permeable drug. Overall, the proposal that ‘phospholipid bilayer diffusion (of drugs) is negligible’ is not disproved by the calculations of ‘likely’ transporter-based fluxes

Towards seamless interfacing between dynamic languages and native code

Existing approaches to interfacing high- and low-level code push considerable burdens onto the programmer, such as wrapper maintenance, explicit code generation, interface re-declaration, and/or signalling to garbage collectors. We note that run-time information on data layout and allocations in native code is available, and may be extended with knowledge of object lifetimes to assist in automating garbage collection. We describe work in progress towards an extension of the CPython virtual machine along these lines. We report initial experience building a first working prototype,and some early performance experiments

Evaluating programming systems design

Research on programming systems design needs to consider a wide range of aspects in their full complexity. This includes user interaction, implementation, interoperability but also the sustainability of its ecosystem and wider societal impact. Established methods of evaluation, such as formal proofs or user studies, impose a reductionist view that makes it difficult to see programming systems in their full complexity and, consequently, force researchers to adopt simplistic perspectives. This paper asks whether we can create more amenable methods of evaluation derived from existing informal practices such as multimedia essays, demos, and interactive tutorials. These popular forms incorporate recorded or scaffolded interaction, often embedded in a text that guides the reader. Can we augment such forms with structure and guidelines to obtain methods of evaluation suitable for peer review? We do not answer this question, but merely seek to identify some of the problems and instigate a community discussion. In that spirit we propose to hold a panel session at the conference

The Missing Link: Explaining ELF Static Linking, Semantically

Beneath the surface, software usually depends on com- plex linker behaviour to work as intended. Even linking hello_world.c is surprisingly involved, and systems software such as libc and operating system kernels rely on a host of linker features. But linking is poorly understood by working programmers and has largely been neglected by language researchers. In this paper we survey the many use-cases that linkers support and the poorly specified linker speak by which they are controlled: metadata in object files, command-line options, and linker-script language. We provide the first validated formalisation of a realistic executable and linkable format (ELF), and capture aspects of the Application Binary Interfaces for four mainstream platforms (AArch64, AMD64, Power64, and IA32). Using these, we develop an executable specification of static linking, covering (among other things) enough to link small C programs (we use the example of bzip2) into a correctly running executable. We provide our specification in Lem and Isabelle/HOL forms. This is the first formal specification of mainstream linking. We have used the Isabelle/HOL version to prove a sample correctness property for one case of AMD64 ABI relocation, demonstrating that the specification supports formal proof, and as a first step towards the much more ambitious goal of verified linking. Our work should enable several novel strands of research, including linker-aware verified compilation and program analysis, and better languages for controlling linking.We acknowledge funding from EPSRC grants EP/H005633 (Leadership Fellowship, Sewell) and EP/K008528 (REMS: Rigorous Engineering for Mainstream Systems Programme Grant).This is the final version of the article. It first appeared from Association for Computing Machinery via https://doi.org/10.1145/3022671.298399